"""
操作系统管理缓存
提供操作系统数据的缓存机制，提升查询性能
"""

import logging
import time
from typing import Dict, Any, Optional, List
from threading import Lock

logger = logging.getLogger(__name__)

class OsCache:
    """操作系统缓存类"""
    
    def __init__(self, cache_ttl: int = 300):
        """
        初始化缓存
        
        Args:
            cache_ttl: 缓存过期时间（秒），默认5分钟
        """
        self.cache_ttl = cache_ttl
        self.os_cache: Dict[str, Dict[str, Any]] = {}
        self.statistics_cache: Dict[str, Any] = {}
        self.cache_timestamps: Dict[str, float] = {}
        self.lock = Lock()
    
    def get_os(self, os_id: str) -> Optional[Dict[str, Any]]:
        """
        从缓存获取操作系统信息
        
        Args:
            os_id: 操作系统ID
            
        Returns:
            操作系统信息或None
        """
        with self.lock:
            if os_id in self.os_cache:
                # 检查缓存是否过期
                if self._is_cache_valid(os_id):
                    logger.debug(f"从缓存获取操作系统: {os_id}")
                    return self.os_cache[os_id].copy()
                else:
                    # 缓存过期，删除
                    del self.os_cache[os_id]
                    del self.cache_timestamps[os_id]
        
        return None
    
    def set_os(self, os_id: str, os_data: Dict[str, Any]) -> None:
        """
        设置操作系统缓存
        
        Args:
            os_id: 操作系统ID
            os_data: 操作系统数据
        """
        with self.lock:
            self.os_cache[os_id] = os_data.copy()
            self.cache_timestamps[os_id] = time.time()
            logger.debug(f"设置操作系统缓存: {os_id}")
    
    def delete_os(self, os_id: str) -> None:
        """
        删除操作系统缓存
        
        Args:
            os_id: 操作系统ID
        """
        with self.lock:
            if os_id in self.os_cache:
                del self.os_cache[os_id]
                del self.cache_timestamps[os_id]
                logger.debug(f"删除操作系统缓存: {os_id}")
    
    def get_statistics(self) -> Optional[Dict[str, Any]]:
        """
        从缓存获取统计信息
        
        Returns:
            统计信息或None
        """
        with self.lock:
            cache_key = 'statistics'
            if cache_key in self.statistics_cache:
                if self._is_cache_valid(cache_key):
                    logger.debug("从缓存获取统计信息")
                    return self.statistics_cache[cache_key].copy()
                else:
                    del self.statistics_cache[cache_key]
                    del self.cache_timestamps[cache_key]
        
        return None
    
    def set_statistics(self, statistics: Dict[str, Any]) -> None:
        """
        设置统计信息缓存
        
        Args:
            statistics: 统计信息
        """
        with self.lock:
            cache_key = 'statistics'
            self.statistics_cache[cache_key] = statistics.copy()
            self.cache_timestamps[cache_key] = time.time()
            logger.debug("设置统计信息缓存")
    
    def get_asset_os_list(self, asset_id: str) -> Optional[List[Dict[str, Any]]]:
        """
        从缓存获取设备资产下的操作系统列表
        
        Args:
            asset_id: 设备资产ID
            
        Returns:
            操作系统列表或None
        """
        with self.lock:
            cache_key = f'asset_os_list_{asset_id}'
            if cache_key in self.os_cache:
                if self._is_cache_valid(cache_key):
                    logger.debug(f"从缓存获取设备资产 {asset_id} 的操作系统列表")
                    return self.os_cache[cache_key].copy()
                else:
                    del self.os_cache[cache_key]
                    del self.cache_timestamps[cache_key]
        
        return None
    
    def set_asset_os_list(self, asset_id: str, os_list: List[Dict[str, Any]]) -> None:
        """
        设置设备资产下的操作系统列表缓存
        
        Args:
            asset_id: 设备资产ID
            os_list: 操作系统列表
        """
        with self.lock:
            cache_key = f'asset_os_list_{asset_id}'
            self.os_cache[cache_key] = [os_data.copy() for os_data in os_list]
            self.cache_timestamps[cache_key] = time.time()
            logger.debug(f"设置设备资产 {asset_id} 的操作系统列表缓存")
    
    def clear_cache(self, os_id: Optional[str] = None) -> None:
        """
        清除缓存
        
        Args:
            os_id: 特定操作系统ID，如果为None则清除所有缓存
        """
        with self.lock:
            if os_id:
                # 清除特定操作系统的缓存
                if os_id in self.os_cache:
                    del self.os_cache[os_id]
                    del self.cache_timestamps[os_id]
                    logger.debug(f"清除操作系统 {os_id} 的缓存")
                
                # 清除相关的设备资产列表缓存
                keys_to_delete = []
                for key in self.os_cache.keys():
                    if key.startswith('asset_os_list_'):
                        # 检查该设备资产的操作系统列表是否包含该操作系统
                        os_list = self.os_cache[key]
                        if any(os_data.get('os_id') == os_id for os_data in os_list):
                            keys_to_delete.append(key)
                
                for key in keys_to_delete:
                    del self.os_cache[key]
                    del self.cache_timestamps[key]
                    logger.debug(f"清除相关的设备资产操作系统列表缓存: {key}")
            else:
                # 清除所有缓存
                self.os_cache.clear()
                self.statistics_cache.clear()
                self.cache_timestamps.clear()
                logger.debug("清除所有缓存")
    
    def clear_statistics_cache(self) -> None:
        """清除统计信息缓存"""
        with self.lock:
            cache_key = 'statistics'
            if cache_key in self.statistics_cache:
                del self.statistics_cache[cache_key]
                del self.cache_timestamps[cache_key]
                logger.debug("清除统计信息缓存")
    
    def get_cache_info(self) -> Dict[str, Any]:
        """
        获取缓存信息
        
        Returns:
            缓存信息字典
        """
        with self.lock:
            current_time = time.time()
            total_items = len(self.os_cache) + len(self.statistics_cache)
            
            # 计算过期项目数
            expired_items = 0
            for key in list(self.cache_timestamps.keys()):
                if current_time - self.cache_timestamps[key] > self.cache_ttl:
                    expired_items += 1
            
            return {
                'total_items': total_items,
                'expired_items': expired_items,
                'cache_ttl': self.cache_ttl,
                'os_cache_size': len(self.os_cache),
                'statistics_cache_size': len(self.statistics_cache),
                'cache_keys': list(self.os_cache.keys()) + list(self.statistics_cache.keys())
            }
    
    def _is_cache_valid(self, cache_key: str) -> bool:
        """
        检查缓存是否有效
        
        Args:
            cache_key: 缓存键
            
        Returns:
            True if cache is valid, False otherwise
        """
        if cache_key not in self.cache_timestamps:
            return False
        
        return (time.time() - self.cache_timestamps[cache_key]) < self.cache_ttl
    
    def cleanup_expired_cache(self) -> int:
        """
        清理过期的缓存项
        
        Returns:
            清理的项目数量
        """
        with self.lock:
            current_time = time.time()
            expired_keys = []
            
            for key, timestamp in self.cache_timestamps.items():
                if current_time - timestamp > self.cache_ttl:
                    expired_keys.append(key)
            
            # 删除过期的缓存项
            for key in expired_keys:
                if key in self.os_cache:
                    del self.os_cache[key]
                if key in self.statistics_cache:
                    del self.statistics_cache[key]
                del self.cache_timestamps[key]
            
            if expired_keys:
                logger.debug(f"清理了 {len(expired_keys)} 个过期的缓存项")
            
            return len(expired_keys)